/*
package com.example.demo.Logger;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.io.FileWriter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;

*/
/**
 * @author lee
 * @date 2021年06月17日 14:17
 *//*

@Slf4j
@Aspect
@Component
public class LogAspect {

    private HashMap<String, Object> map = new HashMap<>();
    private final String filePath = "E:\\IDEA仓库\\my-notes\\我的工作笔记\\src\\main\\java\\Es\\Es京东爬虫搜索实战\\logFile.txt";

    */
/**
     * 切入点
     * 匹配top.alanlee.template.controller包及其子包下的所有类的所有方法
     * com.example.demo.controller
     *//*

    @Pointcut("execution(public * com.example.demo.controller.*.*(..)) & @annotation(com.example.demo.Permission)")
    public void pointCut() {

    }

    */
/**
     * 前置通知，目标方法调用前被调用
     *//*

    @Before("pointCut()")
    public void beforeAdvice(JoinPoint joinPoint) throws NoSuchMethodException {
        // System.out.println("aspect is run!!");
        Object[] args = joinPoint.getArgs();
        // 方法签名
        Signature signature1 = joinPoint.getSignature();
        // 获取的是代理类的method对象
        Method method1 = ((MethodSignature) signature1).getMethod();
        // 这个方法才是目标对象上有注解的方法
        Method realMethod = joinPoint.getTarget().getClass().getDeclaredMethod(signature1.getName(), method1.getParameterTypes());
        // 取出对应的注解
        String name = "";
        int num = -1;
        Annotation[][] parameterAnnotations = realMethod.getParameterAnnotations();
        A:
        for (Annotation[] annotations : parameterAnnotations) {
            for (Annotation annotation : annotations) {
                //获取注解名
                name = annotation.annotationType().getSimpleName();
                num = num + 1;
                if (name.equals("Params")) {
                    break A;
                }
            }
        }

        //获取注解
        //User user = method.getAnnotation(User.class);
        if(name.equals("Params")){
            System.out.println(name);
        } else {
            //没有这个注解的不验证登录，继续处理业务
        }




//        log.info("----------- 前置通知 -----------");
//        Signature signature = joinPoint.getSignature();
//
//        log.info("返回目标方法的签名：{}", signature);
//        log.info("代理的是哪一个方法：{}", signature.getName());
//        Object[] args = joinPoint.getArgs();
//        log.info("获取目标方法的参数信息：{}", Arrays.asList(args));
//
//        map.put("方法签名", signature);
//        map.put("代理方法", signature.getName());
//        map.put("参数信息", Arrays.asList(args));
    }

    */
/**
     * 最终通知，目标方法执行完之后执行
     *//*

    @After("pointCut()")
    public void afterAdvice() {
        log.info("----------- 最终通知 -----------");
    }

    */
/**
     * 后置返回通知
     * 如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
     * 如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
     * returning 只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行
     *
     * @param joinPoint
     * @param keys
     *//*

    @AfterReturning(pointcut = "pointCut()", returning = "keys")
    public void afterReturningAdvice(JoinPoint joinPoint, String keys) {
        log.info("----------- 后置返回通知 -----------");
        log.info("后置返回通知的返回值：{}", keys);
    }

    */
/**
     * 后置异常通知
     * 定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；
     * throwing 只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，
     *
     * @param joinPoint
     * @param e
     *//*

    @AfterThrowing(value = "pointCut()", throwing = "e")
    public void afterThrowingAdvice(JoinPoint joinPoint, NullPointerException e) {
        log.info("----------- 后置异常通知 -----------");
    }

    */
/**
     * 环绕通知
     * 环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
     * 环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
     *
     * @param proceedingJoinPoint
     *//*

    @Around(value = "pointCut()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
        log.info("----------- 环绕通知 -----------");
        log.info("环绕通知的目标方法名：{}", proceedingJoinPoint.getSignature().getName());
        map.put("目标方法", proceedingJoinPoint.getSignature().getName());
        try {
            Object proceed = proceedingJoinPoint.proceed();
            return proceed;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            log.info("---------- 环绕通知结束 -------------");
            //writeLog(map);
        }
        return null;
    }

    void writeLog(HashMap<String, Object> map) {
        try {
            long currentTimeMillis = System.currentTimeMillis();
            SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日-hh时mm分ss秒");
            Date date = new Date(currentTimeMillis);
            FileWriter fw = new FileWriter(filePath, true);
            fw.write("----------- 环绕通知 -----------" + format.format(date) + "\r\n");
            fw.write("环绕通知的目标方法名：" + (String) map.get("目标方法") + "\r\n");
            fw.write("----------- 前置通知 -----------" + "\r\n");
            fw.write("返回目标方法的签名：" + (String) map.get("方法签名").toString() + "\r\n");
            fw.write("代理的是哪一个方法：" + (String) map.get("代理方法") + "\r\n");
            fw.write("获取目标方法的参数信息：" + (String) map.get("参数信息").toString() + "\r\n");
            fw.write("----------- 最终通知 -----------" + "\r\n");
            fw.write("---------- 环绕通知结束 -------------" + "\r\n");
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


}
*/
